import json
import os
import sqlite3
import re
import wx

from config import Note_X, Note_Y, DB_PATH, DEFAULT_CLOSE_SPEED, NOTEBOOK_TABLE
from utils.pyinstaller_get_temp import GetIcoTemp
from utils.screen_size import ScreenSize


class MyNotebookPage(wx.Panel):
    def __init__(self, parent, title, cursor, conn):
        super(MyNotebookPage, self).__init__(parent,
                                             style=wx.CAPTION | wx.MINIMIZE_BOX | wx.MAXIMIZE_BOX | wx.CLOSE_BOX)
        self.conn = conn
        self.cursor = cursor
        self.title = title
        self.sizer = wx.BoxSizer(wx.VERTICAL)

        self.text_ctrl = wx.TextCtrl(self, style=wx.TE_MULTILINE)
        self.Bind(wx.EVT_TEXT, self.on_text_update, self.text_ctrl)

        self.sizer.Add(self.text_ctrl, 1, wx.EXPAND | wx.ALL, 1)
        self.SetSizer(self.sizer)

        # 绑定键盘事件
        self.text_ctrl.Bind(wx.EVT_CHAR, self.on_char)

    # 绑定键盘事件
    def on_char(self, event):
        # 检查是否按下了Tab键
        if event.GetKeyCode() == wx.WXK_TAB:
            # 阻止默认的Tab处理（如果有的话）
            event.Skip(False)
            # 在文本控件的当前位置插入制表符
            pos = self.text_ctrl.GetInsertionPoint()
            self.text_ctrl.WriteText('\t')
            # 如果需要，可以将光标移动到制表符之后
            self.text_ctrl.SetInsertionPoint(pos + 1)
        else:
            # 对于其他键，保持默认行为
            event.Skip()

    # 文本框更新事件（自动保存内容到数据库）
    def on_text_update(self, event):
        # 查询是否有数据,如果有数据则更新，否则插入
        converted_title = self.convert_punctuation_to_chinese(self.title)  # 将英文符号转换为中文
        datas_sql = "select * from " + converted_title
        self.cursor.execute(datas_sql)
        datas = self.cursor.fetchall()
        if len(datas) == 0:
            try:
                sql = "insert into {} (text) values(?)".format(converted_title)
                self.cursor.execute(sql, (self.text_ctrl.GetValue(),))
                self.conn.commit()
            except Exception as e:
                wx.MessageBox("保存失败", "提示", wx.OK | wx.ICON_ERROR)
        else:
            try:
                sql = "update {} SET text = ?".format(converted_title)
                self.cursor.execute(sql, (self.text_ctrl.GetValue(),))
                self.conn.commit()
            except Exception as e:
                wx.MessageBox("保存失败", "提示", wx.OK | wx.ICON_ERROR)

    def convert_punctuation_to_chinese(self, text):
        # 定义英文和中文标点的映射关系
        punctuation_mapping = {
            '.': '。',
        }

        # 使用正则表达式替换文本中的标点
        import re
        for en_punct, cn_punct in punctuation_mapping.items():
            pattern = re.escape(en_punct)  # 转义特殊字符，以便在正则表达式中使用
            text = re.sub(pattern, cn_punct, text)

        return text


class NoteBook(wx.Frame):
    def __init__(self, parent, title):
        # style = wx.DEFAULT_DIALOG_STYLE | wx.RESIZE_BORDER | wx.MAXIMIZE_BOX | wx.MINIMIZE_BOX
        super(NoteBook, self).__init__(parent, title=title)

        note_ico_files = GetIcoTemp().get_note_ico_temp()
        if os.path.exists(note_ico_files):
            self.SetIcon(wx.Icon(GetIcoTemp().get_note_ico_temp(), wx.BITMAP_TYPE_ICO))

        # 初始透明度设置为255（完全不透明）
        self.alpha = 255

        self.SetSize(Note_X, Note_Y)
        screen_width, screen_height = ScreenSize().get_screen_size()
        self.SetPosition(
            (int(screen_width / 2) - int(Note_X / 2), int(screen_height / 5)))  # 设置窗口位置为屏幕大小的一半，并减去窗口的一半，即居中了
        self.Bind(wx.EVT_CLOSE, self.on_close)  # 关闭窗口
        self.notebook = wx.Notebook(self)

        # # 配置选项卡的字体大小
        # font = wx.Font(15, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD,)
        # self.notebook.SetFont(font)

        # 设置选项卡的大小
        # tab_size = (820, 30)  # 宽度200像素，高度30像素
        # self.notebook.SetMaxSize(tab_size)

        # 设置选项卡的间距和边距
        # 读取已保存的页签
        self.load_pages()

        # 布局
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(self.notebook, 1, wx.EXPAND | wx.ALL, 0)
        self.SetSizer(sizer)

        # 绑定便签的右键菜单事件
        self.notebook.Bind(wx.EVT_RIGHT_UP, self.on_right_click)

        # 在空白区域创建右键菜单
        self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)

        self.on_right_down()

    # 切换置顶
    def on_toggle_button_click(self, panel):
        # 切换置顶状态
        self.is_always_on_top = not self.is_always_on_top
        self.Raise()  # 将窗口置顶
        style = self.GetWindowStyle()
        new_style = style ^ wx.STAY_ON_TOP
        self.SetWindowStyle(new_style)  # 切换窗口的STAY_ON_TOP样式

        # 更新菜单项的文本
        if self.is_always_on_top:
            self.is_top.SetItemLabel('☟ 取消置顶')
            self.is_top.SetBackgroundColour("red")
        else:
            self.is_top.SetItemLabel('☝ 置顶')

    # 在空白区域添加右键菜单（新建便签）
    def on_right_down(self):
        self.menu = wx.Menu()
        # 添加菜单项
        self.Bind(wx.EVT_MENU, self.on_add_page, self.menu.Append(wx.ID_ANY, '➕ 新建'))
        self.Bind(wx.EVT_MENU, self.on_options_button_click, self.menu.Append(wx.ID_ANY, '✏ 选项'))
        self.is_top = self.menu.Append(wx.ID_ANY, '☝ 置顶')
        self.Bind(wx.EVT_MENU, self.on_toggle_button_click, self.is_top)

        self.is_always_on_top = False

    # 显示右键菜单
    def OnRightDown(self, event):
        self.PopupMenu(self.menu, event.GetPosition())
        # self.PopupMenu(menu, event.GetPosition())
        # menu.Destroy()

    # 关闭窗口
    def on_close(self, event):
        # 创建一个定时器，用于逐渐改变窗口的透明度
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.on_timer, self.timer)
        self.timer.Start(15)  # 每10毫秒触发一次定时器事件

    def on_timer(self, event):
        # 逐渐减小窗口的透明度
        self.alpha -= DEFAULT_CLOSE_SPEED
        if self.alpha < 0:
            self.alpha = 0
            self.timer.Stop()  # 停止定时器
            self.Destroy()  # 销毁窗口
            return

        # 设置窗口的透明度（注意：这里的方法可能因操作系统和wxPython版本而异）
        # 在某些平台上，可能需要使用其他方法来设置窗口的透明度
        # 例如，使用SetWindowStyleFlag和SetTransparent方法，但这通常用于完全透明或完全不透明的窗口
        # 对于平滑淡出效果，可能需要使用平台特定的API或库来实现窗口透明度的渐变
        # 由于wxPython的标准API不直接支持窗口透明度的渐变，以下代码可能无法在所有平台上工作
        # 这里仅作为示例代码，展示如何结合定时器和透明度变化来实现平滑淡出效果的概念
        # 在实际应用中，可能需要使用其他方法或库来实现这一效果
        self.SetTransparent(self.alpha)  # 注意：这个方法可能不起作用，因为wxPython的SetTransparent通常用于完全透明或完全不透明的窗口

        # 如果上面的代码不起作用，可以尝试使用平台特定的方法或库来实现窗口透明度的渐变效果
        # 例如，在Windows平台上，可以使用Win32 API来设置窗口的透明度
        # 在Linux平台上，可以使用X11相关的库来实现窗口透明度的渐变效果
        # 这些方法超出了wxPython的标准功能范围，需要额外的编程工作来实现

    # 初始化数据库连接
    def get_database_conn(self):
        abs_db_path = os.path.join(DB_PATH, "notebook.db")
        if not os.path.exists(abs_db_path):
            wx.MessageBox("数据库路径不存在")
            return
        try:
            conn = sqlite3.connect(abs_db_path)
            cursor = conn.cursor()
        except sqlite3.Error as e:
            wx.MessageBox("{}".format(e))
            return
        else:
            return conn, cursor

    # 查询数据库内容
    def get_database_datas(self):
        conn, cursor = self.get_database_conn()
        select_sql = f"""SELECT * FROM {NOTEBOOK_TABLE}"""
        try:
            cursor.execute(select_sql)
            datas = cursor.fetchall()
        except Exception as e:
            wx.MessageBox("查询数据库失败:{}".format(e))
            return
        else:
            json_str = datas[0][0]
            # 将字符串解析为字典
            data_dict = json.loads(json_str)
            return data_dict
        finally:
            conn.close()

    # 返回所有的表
    def db_all_tables(self):
        sql_all_table = "SELECT name FROM sqlite_master WHERE type='table'"
        conn, cursor = self.get_database_conn()
        try:
            cursor.execute(sql_all_table)
            all_tables = cursor.fetchall()
            return all_tables
        except Exception as e:
            wx.MessageBox("{}".format(e))
        finally:
            cursor.close()

    # 读取已保存的页签即数据
    def load_pages(self):
        databasese_dict = self.get_database_datas()
        conn, cursor = self.get_database_conn()
        all_tables = self.db_all_tables()
        # 配置便签标题的字体大小及粗细
        if databasese_dict["note_title_font_type"] == "粗体":
            font_weight = wx.FONTWEIGHT_BOLD
        elif databasese_dict["note_title_font_type"] == "细体":
            font_weight = wx.FONTWEIGHT_LIGHT
        else:
            font_weight = wx.FONTWEIGHT_NORMAL

        font = wx.Font(databasese_dict["note_title_font_size"], wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, font_weight,faceName=databasese_dict["note_font_type"])
        self.notebook.SetFont(font)

        # 配置便签标题栏背景颜色
        self.notebook.SetBackgroundColour(databasese_dict["note_title_back_color"])  # 背景颜色

        for name in all_tables:
            pattern = re.compile(r'[\u4e00-\u9fff]+')  # 检测是否包含中文
            pattern2 = re.compile(r'[\u3000-\u303F]+')  # 检测是否有中文格式的标点符号

            match = pattern.search(name[0])
            matches = pattern2.findall(name[0])
            if match or matches:
                page_name = name[0]
                # 便签名字
                page_name_english = page_name.replace('。', '.')  # 显示便签的时候把中文的句号显示成.
                page = MyNotebookPage(self.notebook, page_name_english, cursor, conn)
                page.SetBackgroundColour(databasese_dict["note_border_color"])  # 设置窗口边框背景颜色
                self.notebook.AddPage(page, page_name_english)
                # 文本内容为空时也显示背景颜色
                page.text_ctrl.SetBackgroundColour(databasese_dict["note_back_color"])  # 背景颜色
                cursor.execute("SELECT * FROM " + page_name)
                # 便签中的数据
                datas = cursor.fetchall()
                if len(datas) > 0:
                    page.text_ctrl.SetValue(datas[0][0])
                    # 设置文本颜色及背景颜色
                    page.text_ctrl.SetForegroundColour(databasese_dict["note_font_color"])  # 字体颜色
                    page.text_ctrl.SetBackgroundColour(databasese_dict["note_back_color"])  # 背景颜色
                    # 字体大小
                    page.text_ctrl.SetFont(
                        wx.Font(databasese_dict["note_font_size"], wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL,
                                faceName=databasese_dict["note_font_type"]))

        page_count = self.notebook.GetPageCount()
        if page_count == 0:
            # 如果窗口中没有便签，则添加默认提醒文字
            font = wx.StaticText(self,
                                 label="在空白区域点击右键创建便签(之后需在上方已创建的便签名称后面空白处点击右键新建)！",
                                 pos=(Note_X - 950, Note_Y - 380))
            font.SetFont(wx.Font(12, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, faceName='仿宋'))
            font.SetBackgroundColour(wx.Colour("#F9F9F9"))

    def convert_punctuation_to_chinese(self, text):
        # 定义英文和中文标点的映射关系
        punctuation_mapping = {
            '.': '。'
        }

        # 使用正则表达式替换文本中的标点
        import re
        for en_punct, cn_punct in punctuation_mapping.items():
            pattern = re.escape(en_punct)  # 转义特殊字符，以便在正则表达式中使用
            text = re.sub(pattern, cn_punct, text)

        return text

    # 新增便签
    def on_add_page(self, event):
        databasese = self.get_database_datas()
        all_tables = self.db_all_tables()
        conn, cursor = self.get_database_conn()
        title = wx.GetTextFromUser("", "输入便签名称（中文）")
        if title.isascii() and title.isalpha():
            wx.MessageBox("不能输入全英文", "提示", wx.OK | wx.ICON_INFORMATION)
            return
        if title:
            for table in all_tables:
                if table[0] == title:
                    wx.MessageBox("已存在该名称的便签！", "提示", wx.OK | wx.ICON_INFORMATION)
                    return
            try:
                converted_title = self.convert_punctuation_to_chinese(title)
                cursor.execute("CREATE TABLE " + converted_title + " (text)")
                conn.commit()
            except Exception as e:
                wx.MessageBox("不支持以数字开头、不支持英文状态下的符号、不支持全英文名称", "提示", wx.OK | wx.ICON_ERROR)
                return
            page = MyNotebookPage(self.notebook, title, cursor, conn)
            page.SetBackgroundColour(databasese["note_border_color"])  # 笔记边框颜色
            self.notebook.AddPage(page, title)
            # 新增的标签设置文本颜色及背景颜色
            page.text_ctrl.SetForegroundColour(databasese["note_font_color"])  # 字体颜色
            page.text_ctrl.SetBackgroundColour(databasese["note_back_color"])  # 背景颜色
            # 新增便签后自动切换到该标签
            self.notebook.SetSelection(self.notebook.GetPageCount() - 1)

            # 字体大小
            page.text_ctrl.SetFont(
                wx.Font(databasese["note_font_size"], wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL,
                        faceName=databasese["note_font_type"]))

    # 选项按钮点击事件
    def on_options_button_click(self, event):
        dlg = SettingsDialog(self)
        dlg.ShowModal()
        dlg.Destroy()

    # 在便签上添加右键菜单
    def on_right_click(self, event):
        # 获取便签索引 index[0]
        point = event.GetPosition()
        index = self.notebook.HitTest(point)

        if index != wx.NOT_FOUND:
            popupmenu = wx.Menu()
            rename_item = wx.MenuItem(popupmenu, wx.ID_ANY, '重命名')
            delete_item = wx.MenuItem(popupmenu, wx.ID_ANY, '删除')
            popupmenu.Append(rename_item)
            popupmenu.Append(delete_item)

            # 把index传递给菜单项的回调函数
            self.Bind(wx.EVT_MENU, lambda event, arg=index[0]: self.on_rename_page(event, arg), rename_item)
            self.Bind(wx.EVT_MENU, lambda event, arg=index[0]: self.on_delete_page(event, arg), delete_item)

            self.PopupMenu(popupmenu)
            popupmenu.Destroy()

    # 重命名便签
    def on_rename_page(self, event, index):
        page = self.notebook.GetPage(index)
        conn, cursor = self.get_database_conn()
        if page:
            old_title_converted_title = self.convert_punctuation_to_chinese(page.title)
            old_title = old_title_converted_title
            dialog = wx.TextEntryDialog(self, '输入新的便签名称:', '重命名', page.title)
            if dialog.ShowModal() == wx.ID_OK:
                new_title = dialog.GetValue()
                new_title_converted_title = self.convert_punctuation_to_chinese(new_title)
                if new_title_converted_title != old_title:
                    # 检查旧文件是否存在
                    all_tables = self.db_all_tables()
                    for table in all_tables:
                        if table[0] == new_title_converted_title:
                            wx.MessageBox("已存在该名称的便签！", "提示", wx.OK | wx.ICON_INFORMATION)
                            return
                    try:
                        # 重命名文件
                        # print(old_title, new_title_converted_title)
                        cursor.execute("ALTER TABLE {} RENAME TO {}".format(old_title, new_title_converted_title))
                        conn.commit()
                        # 更新页签标题
                        page.title = new_title
                        self.notebook.SetPageText(index, new_title)
                    except Exception as e:
                        wx.MessageBox(f'不支持以数字开头、不支持英文状态下的符号、不支持全英文名称: {e}', '错误',
                                      wx.OK | wx.ICON_ERROR)
            dialog.Destroy()

    # 删除便签
    def on_delete_page(self, event, index):
        conn, cursor = self.get_database_conn()
        page = self.notebook.GetPage(index)
        converted_title = self.convert_punctuation_to_chinese(page.title)
        if page:
            # 弹窗提示是否删除
            dialog = wx.MessageDialog(self, '是否删除 【 {} 】?'.format(page.title), '警告',
                                      wx.YES_NO | wx.ICON_WARNING)
            if dialog.ShowModal() == wx.ID_YES:
                # 删除数据库的表
                try:
                    cursor.execute("DROP TABLE {}".format(converted_title))
                    conn.commit()
                except Exception as e:
                    wx.MessageBox(f'删除便签时发生错误: {e}', '错误', wx.OK | wx.ICON_ERROR)
                # 同步删除页签
                self.notebook.DeletePage(index)


class SettingsDialog(wx.Dialog):
    def __init__(self, parent):
        super(SettingsDialog, self).__init__(parent, title="参数设置")
        self.SetSize((310, 350))
        # 绑定关闭窗口
        self.Bind(wx.EVT_CLOSE, self.on_close)
        font = ["Arial", "宋体", "仿宋", "黑体", "楷体", "微软雅黑", "隶书", "新宋体", "幼圆", "华文中宋", "华文细黑",
                "华文琥珀", "华文楷体", "方正姚体", "等线", "方正舒体"]
        wx.StaticText(self, label="字体", pos=(20, 10))
        self.font = wx.Choice(self, choices=font, size=(160, 25))
        self.font.SetPosition((100, 10))
        # 读取数据库中的字体
        database_font = self.get_database_datas()["note_font_type"]
        if database_font in font:
            index = font.index(database_font)
            self.font.SetSelection(index)

        wx.StaticText(self, label="字体大小", pos=(20, 45))
        database_font_size = self.get_database_datas()["note_font_size"]  # 读取数据库中的字体大小
        self.font_size = wx.SpinCtrl(self, min=8, max=24, initial=database_font_size, size=(160, 20))
        self.font_size.SetPosition((100, 45))

        wx.StaticText(self, label="字体颜色", pos=(20, 80))
        database_font_color = self.get_database_datas()["note_font_color"]  # 读取数据库中的字体颜色
        self.font_color = wx.TextCtrl(self, value=database_font_color, size=(100, 20))
        self.font_color.SetPosition((100, 80))
        # self.font_color.SetForegroundColour(database_font_color)
        # 展示颜色标签
        self.font_color_lable = wx.Button(self, label="", pos=(202, 83), size=(17, 16))
        self.font_color_lable.SetBackgroundColour(database_font_color)
        wx.Button(self, label="选择", pos=(220, 80), size=(45, 20)).Bind(wx.EVT_BUTTON, self.font_select_color)

        wx.StaticText(self, label="背景颜色", pos=(20, 115))
        database_back_color = self.get_database_datas()["note_back_color"]  # 读取数据库中的背景颜色
        self.background_color = wx.TextCtrl(self, value=database_back_color, size=(100, 20))
        self.background_color.SetPosition((100, 115))
        # self.background_color.SetForegroundColour(database_back_color)
        # 展示颜色标签
        self.back_color_lable = wx.Button(self, label="", pos=(202, 118), size=(17, 16))
        self.back_color_lable.SetBackgroundColour(database_back_color)
        wx.Button(self, label="选择", pos=(220, 115), size=(45, 20)).Bind(wx.EVT_BUTTON, self.back_select_color)

        wx.StaticText(self, label="边框颜色", pos=(20, 145))
        database_note_border_color = self.get_database_datas()["note_border_color"]  # 读取数据库中的边框颜色
        self.note_border_color = wx.TextCtrl(self, value=database_note_border_color, size=(100, 20))
        self.note_border_color.SetPosition((100, 145))
        # 展示颜色标签
        self.border_color_lable = wx.Button(self, label="", pos=(202, 148), size=(17, 16))
        self.border_color_lable.SetBackgroundColour(database_note_border_color)
        wx.Button(self, label="选择", pos=(220, 145), size=(45, 20)).Bind(wx.EVT_BUTTON, self.border_select_color)

        wx.StaticText(self, label="标题栏背景色", pos=(20, 175))
        database_note_title_back_color = self.get_database_datas()["note_title_back_color"]  # 标题栏背景色
        self.note_title_back_color = wx.TextCtrl(self, value=database_note_title_back_color, size=(100, 20))
        self.note_title_back_color.SetPosition((100, 175))
        # 展示颜色标签
        self.note_title_back_color_lable = wx.Button(self, label="", pos=(202, 178), size=(17, 16))
        self.note_title_back_color_lable.SetBackgroundColour(database_note_title_back_color)
        wx.Button(self, label="选择", pos=(220, 175), size=(45, 20)).Bind(wx.EVT_BUTTON, self.title_back_select_color)

        wx.StaticText(self, label="标题大小", pos=(20, 208))
        database_title_font_size = self.get_database_datas()["note_title_font_size"]  # 读取数据库中的字体大小
        self.title_font_size = wx.SpinCtrl(self, min=8, max=24, initial=database_title_font_size, size=(160, 20))
        self.title_font_size.SetPosition((100, 208))

        type = ["粗体", "正常", "细体"]
        wx.StaticText(self, label="标题字体类型", pos=(20, 238))
        self.title_font_type = wx.Choice(self, choices=type, size=(160, 25))
        self.title_font_type.SetPosition((100, 238))
        # 标题字体类型
        database_type = self.get_database_datas()["note_title_font_type"]
        if database_type in type:
            index = type.index(database_type)
            self.title_font_type.SetSelection(index)

        # 添加确定和取消按钮
        btn_ok = wx.Button(self, label="确定", pos=(70, 280), size=(150, 25))
        btn_ok.Bind(wx.EVT_BUTTON, self.on_submit)

    # 初始化数据库连接
    def get_database_conn(self):
        db_path = DB_PATH
        abs_db_path = os.path.join(db_path, "notebook.db")
        if not os.path.exists(abs_db_path):
            wx.MessageBox("数据库路径不存在")
            return
        try:
            conn = sqlite3.connect(abs_db_path)
            cursor = conn.cursor()
        except sqlite3.Error as e:
            wx.MessageBox("{}".format(e))
            return
        else:
            return conn, cursor

    # 查询数据库内容
    def get_database_datas(self):
        conn, cursor = self.get_database_conn()
        select_sql = f"""SELECT * FROM {NOTEBOOK_TABLE}"""
        try:
            cursor.execute(select_sql)
            datas = cursor.fetchall()
        except Exception as e:
            wx.MessageBox("查询数据库失败{}".format(e))
            return
        else:
            json_str = datas[0][0]
            # 将字符串解析为字典
            data_dict = json.loads(json_str)
            return data_dict
        finally:
            conn.close()

    # 弹出颜色选择器
    def font_select_color(self, event):
        color_dlg = wx.ColourDialog(self)
        if color_dlg.ShowModal() == wx.ID_OK:
            # 获取选择的颜色并更新下拉选择框
            selected_color = color_dlg.GetColourData().GetColour().GetAsString(wx.C2S_HTML_SYNTAX)
            self.font_color.SetValue(selected_color)
            # self.font_color.SetForegroundColour(selected_color)
            # 更新展示颜色标签的颜色
            self.font_color_lable.SetBackgroundColour(selected_color)
            self.font_color.Refresh()
            self.font_color_lable.Refresh()
        color_dlg.Destroy()

    # 弹出颜色选择器
    def back_select_color(self, event):
        color_dlg = wx.ColourDialog(self)
        if color_dlg.ShowModal() == wx.ID_OK:
            # 获取选择的颜色并更新下拉选择框
            selected_color = color_dlg.GetColourData().GetColour().GetAsString(wx.C2S_HTML_SYNTAX)
            self.background_color.SetValue(selected_color)
            # self.background_color.SetForegroundColour(selected_color)

            # 更新展示颜色标签的颜色
            self.back_color_lable.SetBackgroundColour(selected_color)
            self.back_color_lable.Refresh()

            self.background_color.Refresh()
        color_dlg.Destroy()

    # 弹出颜色选择器
    def border_select_color(self, event):
        color_dlg = wx.ColourDialog(self)
        if color_dlg.ShowModal() == wx.ID_OK:
            # 获取选择的颜色并更新下拉选择框
            selected_color = color_dlg.GetColourData().GetColour().GetAsString(wx.C2S_HTML_SYNTAX)
            self.note_border_color.SetValue(selected_color)
            # self.note_border_color.SetForegroundColour(selected_color)

            # 更新展示颜色标签的颜色
            self.border_color_lable.SetBackgroundColour(selected_color)
            self.border_color_lable.Refresh()

            self.note_border_color.Refresh()
        color_dlg.Destroy()

    # 弹出颜色选择器(标题栏背景颜色)
    def title_back_select_color(self, event):
        color_dlg = wx.ColourDialog(self)
        if color_dlg.ShowModal() == wx.ID_OK:
            # 获取选择的颜色并更新下拉选择框
            selected_color = color_dlg.GetColourData().GetColour().GetAsString(wx.C2S_HTML_SYNTAX)
            self.note_title_back_color.SetValue(selected_color)
            # self.note_border_color.SetForegroundColour(selected_color)

            # 更新展示颜色标签的颜色
            self.note_title_back_color_lable.SetBackgroundColour(selected_color)
            self.note_title_back_color_lable.Refresh()

            self.note_title_back_color.Refresh()
        color_dlg.Destroy()

    def on_submit(self, event):
        font = self.font.GetStringSelection()
        background_color = self.background_color.GetValue()
        font_color = self.font_color.GetValue()
        font_size = self.font_size.GetValue()
        note_border_color = self.note_border_color.GetValue()
        note_title_back_color = self.note_title_back_color.GetValue()  # 标题栏背景色
        note_title_font_size = self.title_font_size.GetValue()  # 标题栏字体大小
        note_title_font_type = self.title_font_type.GetStringSelection()  # 标题栏字体粗细
        conn, cursor = self.get_database_conn()

        update_datas = {
            'note_font_type': font,
            'note_font_size': font_size,
            'note_font_color': font_color,
            'note_back_color': background_color,
            'note_border_color': note_border_color,
            'note_title_back_color': note_title_back_color,
            'note_title_font_size': note_title_font_size,
            'note_title_font_type': note_title_font_type,
        }

        # 将字典序列化为JSON字符串
        json_data = json.dumps(update_datas, ensure_ascii=False)

        # 插入数据
        # insert_sql = f"insert into {NOTEBOOK_TABLE} (notebook_options) values (?)"  # 与config中的值保持一致
        insert_sql = f"update {NOTEBOOK_TABLE} set notebook_options=?"  # 与config中的值保持一致

        try:
            cursor.execute(insert_sql, (json_data,))  # 注意这里是一个元组，包含单个元素json_data
            conn.commit()
        except Exception as e:
            wx.MessageBox(caption="提示", message="保存失败：{}".format(e))
            return
        else:
            wx.MessageBox(caption="提示", message="保存成功，重新打开笔记窗口后生效", style=wx.OK | wx.ICON_INFORMATION)
            self.Destroy()  # 关闭窗口
            conn.close()

    def on_close(self, event):
        self.Destroy()  # 销毁窗口，关闭窗口

# if __name__ == '__main__':
#     app = wx.App(False)
#     frame = NoteBook(None, 'Dialog with Rich Text')
#     frame.Show()
#     app.MainLoop()
